package com.ruoyi.exam.service.impl;

import java.util.Date;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson2.JSON;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.exam.domain.entity.ExamPaper;
import com.ruoyi.exam.domain.entity.ExamPaperQuestion;
import com.ruoyi.exam.domain.entity.TTask;
import com.ruoyi.exam.domain.entity.TTaskExamPaper;
import com.ruoyi.exam.domain.entity.TTaskExe;
import com.ruoyi.exam.mapper.ExamPaperMapper;
import com.ruoyi.exam.mapper.ExamPaperQuestionMapper;
import com.ruoyi.exam.mapper.TTaskExamPaperAnswerMapper;
import com.ruoyi.exam.mapper.TTaskExamPaperMapper;
import com.ruoyi.exam.mapper.TTaskExeMapper;
import com.ruoyi.exam.mapper.TTaskMapper;
import com.ruoyi.exam.service.ITTaskService;

/**
 * 任务Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-12-19
 */
@Service
public class TTaskServiceImpl implements ITTaskService {
    @Autowired
    private TTaskMapper tTaskMapper;

    @Autowired
    private TTaskExeMapper tTaskExeMapper;

    @Autowired
    private TTaskExamPaperMapper tTaskExamPaperMapper;

    @Autowired
    private TTaskExamPaperAnswerMapper tTaskExamPaperAnswerMapper;

    @Autowired
    private ExamPaperMapper examPaperMapper;

    @Autowired
    private ExamPaperQuestionMapper examPaperQuestionMapper;


    /**
     * 查询任务
     * 
     * @param id 任务主键
     * @return 任务
     */
    @Override
    public TTask selectTTaskById(Long id) {
        return tTaskMapper.selectTTaskById(id);
    }

    /**
     * 查询任务列表
     * 
     * @param tTask 任务
     * @return 任务
     */
    @Override
    public List<TTask> selectTTaskList(TTask tTask) {
        List<TTask> selectTTaskList = tTaskMapper.selectTTaskList(tTask);
        // 通过selectTTaskList列表内元素的endTime判断是否过期
        // 如果当前日期超过endTime的日期，则设置为过期
        for (TTask task : selectTTaskList) {
            // 获取当前日期（不含时分秒）
            Date today = DateUtils.parseDate(DateUtils.getDate());
            // 获取任务结束日期（不含时分秒）
            Date endDate = DateUtils.parseDate(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, task.getEndTime()));
            // 如果结束日期小于今天，则为过期任务
            task.setExpire(endDate.before(today));

            // 通过任务ID查询taskexe，如果存在记录，则设置任务状态为1
            // TTaskExe tTaskExe = new TTaskExe();
            // tTaskExe.setTaskId(task.getId());
            // List<TTaskExe> tTaskExeList = tTaskExeMapper.selectTTaskExeList(tTaskExe);
            // if (tTaskExeList.size() > 0) {
            //     task.setTaskStatus(3); //已执行
            // } else {
            //     task.setTaskStatus(2); //未执行
            // }
        }
        return selectTTaskList;
    }

    /**
     * 新增任务
     * 
     * @param tTask 任务
     * @return 结果
     */
    @Override
    @Transactional
    public int insertTTask(TTask tTask) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        tTask.setCreateTime(DateUtils.getNowDate());
        tTask.setUpdateTime(DateUtils.getNowDate());
        tTask.setCreateBy(loginUser.getUser().getUserId().toString());
        tTask.setUpdateBy(loginUser.getUser().getUserId().toString());
        // 如果是每日一练任务，需要检测是否有每日一练的配置项
        if(tTask.getType() == 1){
            // 查询每日一练的配置项
            if(tTask.getQuestionConfig() == null){
                throw new RuntimeException("每日一练配置项为空，请重新配置每日一练任务！");
            }
        }

        int rows = tTaskMapper.insertTTask(tTask);

        // 如果不是每日一练类型，则需要关联试卷
        if (tTask.getType() != 1) { // 假设1为每日一练类型，请根据实际的字典值调整
            insertTTaskExamPaper(tTask);
        }
        return rows;
    }

    /**
     * 写入任务绑定的时试卷
     * 
     * @param tTask
     */
    private void insertTTaskExamPaper(TTask tTask) {
        // 查询试卷
        ExamPaper examPaper = examPaperMapper.selectExamPaperById(tTask.getTaskExamPaperId());
        // 查询试卷试题列表
        ExamPaperQuestion examPaperQuestion = new ExamPaperQuestion();
        examPaperQuestion.setExamPaperId(examPaper.getId());
        List<ExamPaperQuestion> examPaperQuestionList = examPaperQuestionMapper
                .selectExamPaperQuestionList(examPaperQuestion);
        examPaper.setExamPaperQuestions(examPaperQuestionList);

        TTaskExamPaper tTaskExamPaper = new TTaskExamPaper();
        tTaskExamPaper.setId(tTask.getId());
        tTaskExamPaper.setTaskId(tTask.getId());
        tTaskExamPaper.setPaperContent(JSON.toJSONString(examPaper));
        tTaskExamPaper.setCreateTime(DateUtils.getNowDate());
        tTaskExamPaper.setUpdateTime(DateUtils.getNowDate());
        tTaskExamPaper.setCreateBy(SecurityUtils.getLoginUser().getUser().getUserId().toString());
        tTaskExamPaper.setUpdateBy(SecurityUtils.getLoginUser().getUserId().toString());
        tTask.settTaskExamPaper(tTaskExamPaper);

        tTaskExamPaperMapper.deleteTTaskExamPaperByTaskId(tTask.getId());
        tTaskExamPaperMapper.insertTTaskExamPaper(tTaskExamPaper);
    }

    /**
     * 修改任务
     * 
     * @param tTask 任务
     * @return 结果
     */
    @Override
    @Transactional
    public int updateTTask(TTask tTask) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        tTask.setUpdateTime(DateUtils.getNowDate());
        tTask.setUpdateBy(loginUser.getUser().getUserId().toString());

        int rows = tTaskMapper.updateTTask(tTask);

        // 如果不是每日一练类型，则需要关联试卷
        if (tTask.getType() != 1) { // 假设1为每日一练类型，请根据实际的字典值调整
            insertTTaskExamPaper(tTask);
        } else {
            // 如果是每日一练类型，需要清除可能存在的试卷关联
            // tTaskExamPaperMapper.deleteTTaskExamPaperByTaskId(tTask.getId());
            // 20250605这里的逻辑去掉，因为每日一练的试卷是自动生成的，不需要手动删除，并且每日一练任务可能已经绑定了试卷，这里修改任务不能影响已经创建的试卷任务
        }

        return rows;
    }

    /**
     * 批量删除任务
     * 
     * @param ids 需要删除的任务主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTTaskByIds(Long[] ids) {
        // 删除关联的试卷数据和执行表数据
        int row = 0;
        for (Long id : ids) {
            row = row + deleteTTaskById(id);
        }
        return row;
    }

    /**
     * 删除任务信息
     * 
     * @param id 任务主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteTTaskById(Long id) {
        // 删除关联的试卷数据
        tTaskExamPaperMapper.deleteTTaskExamPaperByTaskId(id);
        // 删除关联的执行表数据，如果执行表关联了试卷，答题信息，需要把答题信息也删掉
        TTaskExe param = new TTaskExe();
        param.setTaskId(id);
        List<TTaskExe> tTaskExeList = tTaskExeMapper.selectTTaskExeList(param);
        for (TTaskExe tTaskExeList2 : tTaskExeList) {
            if (tTaskExeList2.getTaskExamPaperAnswerId() != null) {
                tTaskExamPaperAnswerMapper.deleteTTaskExamPaperAnswerById(tTaskExeList2.getTaskExamPaperAnswerId());
            }
        }
        tTaskExeMapper.deleteTTaskExeByTaskId(id);
        // 删除任务
        return tTaskMapper.deleteTTaskById(id);
    }
}
